/*
 * RBFKeyNvm.c
 *
 *  Created on: 2023年7月14日
 *      Author: fjx
 *
 */
#include "RBFKeyNvm.h"
#include "util.h"
#include "app_log.h"
#include <stdint.h>
#include "bsp_aes_ccm.h"
#include "bsp_nvm.h"
#include "device.h"
#include "sl_se_manager.h"
#include "sl_se_manager_entropy.h"

key_group_t key_group = {0};

/*
 *@note  软件密钥管理流程
 *@note  读取key的流程: 1. get_key_from_nvm 先根据keyID从nvm区域读取相应的key(密文)
 *@note             2. secure_element_getKey 在根据keyID解密相应的明文key
 *@note
 *@note  设置key的流程: 1. secure_element_setKey 先根据keyID将明文的key加密成密文
 *@note             2. set_key_from_nvm 再将密文的key存储到nvm区域
 *@note
 *
 *
 *
 *
 *
 *
 */
//测试定义
/*
 *@note 所有key测试的顺序必须先设置(set),后读取(get).
 *@note 设置数据源头以key_p明文入口(模拟生产烧录key)
 *@note 和NVM进行数据交换的永远是密文(key_c)
 *
 */
#define xCONFIG_LOG_RBFKEYNVM
#define xKEY_SIM_DEBUG

#if defined (KEY_SIM_DEBUG)
_key_t codeA_key={
    .key_c = {0},
    .key_p = KEY_CODEA_DEFAULT,
    .keyid = 0,
};
_key_t codeB_key={
    .key_c = {0},
    .key_p = KEY_CODEB_DEFAULT,
    .keyid = 0,
};
_key_t codeAB_key={
    .key_c = {0},
    .key_p = KEY_CODEAB_DEFAULT,
    .keyid = 0,
};
_key_t default_key_1={
    .key_c = {0},
    .key_p = KEY_CODEAB_DEFAULT,
    .keyid = 0,
};
_key_t default_key_2={
    .key_c = {0},
    .key_p = {0},
    .keyid = 0,
};
_key_t system_key={
    .key_c = {0},
    .key_p = KEY_SYSTEM_DEFAULT,
    .keyid = 0,
};
_key_t broadcast_key={
    .key_c = {0},
    .key_p = KEY_BROADCAST_DEFAULT,
    .keyid = 0,
};
_key_t nvm_key={
    .key_c = {0},
    .key_p = KEY_NVM_DEFAULT,
    .keyid = 0,
};

#endif

static char *get_status_type_str(SecureElementStatus_t status)
{
  switch (status) {
  case SECURE_ELEMENT_ERROR_NPE:
    return "SECURE ELEMENT ERROR NPE";
  case SECURE_ELEMENT_ERROR_INVALID_KEY_ID:
    return "SECURE ELEMENT ERROR INVALID KEY ID";
  case SECURE_ELEMENT_ERROR_NOT_SUPPORTED:
    return "SECURE ELEMENT ERROR NOT SUPPORTED";


  default:
    return "Unknown status";
  }
}
#if 0
static char *get_event_type_str(KeyEvent_t event)
{
  switch (event) {
  case KEY_EVENT_GET_CODEA:
    return "KEY_EVENT_GET_CODEA";
  case KEY_EVENT_GET_CODEB:
    return "KEY_EVENT_GET_CODEB";
  case KEY_EVENT_GET_CODEAB:
    return "KEY_EVENT_GET_CODEAB";
  case KEY_EVENT_GET_DEFAULT_KEY1:
    return "KEY_EVENT_GET_DEFAULT_KEY1";
  case KEY_EVENT_GET_DEFAULT_KEY2:
    return "KEY_EVENT_GET_DEFAULT_KEY2";
  case KEY_EVENT_GET_SYSTEM_KEY_CODE:
    return "KEY_EVENT_GET_SYSTEM_KEY_CODE";
  case KEY_EVENT_GET_BROADCAST_KEY_CODE:
    return "KEY_EVENT_GET_BROADCAST_KEY_CODE";
  case KEY_EVENT_GET_NVM_KEY:
    return "KEY_EVENT_GET_NVM_KEY";
  case KEY_EVENT_GET_NVM_KEY_EN_KEY:
    return "KEY_EVENT_GET_NVM_KEY_EN_KEY";

  case KEY_EVENT_SET_CODEA:
    return "KEY_EVENT_SET_CODEA";
  case KEY_EVENT_SET_CODEB:
    return "KEY_EVENT_SET_CODEB";
  case KEY_EVENT_SET_CODEAB:
    return "KEY_EVENT_SET_CODEAB";
  case KEY_EVENT_SET_DEFAULT_KEY1:
    return "KEY_EVENT_SET_DEFAULT_KEY1";
  case KEY_EVENT_SET_DEFAULT_KEY2:
    return "KEY_EVENT_SET_DEFAULT_KEY2";
  case KEY_EVENT_SET_SYSTEM_KEY_CODE:
    return "KEY_EVENT_SET_SYSTEM_KEY_CODE";
  case KEY_EVENT_SET_BROADCAST_KEY_CODE:
    return "KEY_EVENT_SET_BROADCAST_KEY_CODE";
  case KEY_EVENT_SET_NVM_KEY:
    return "KEY_EVENT_SET_NVM_KEY";
  case KEY_EVENT_SET_NVM_KEY_EN_KEY:
    return "KEY_EVENT_SET_NVM_KEY_EN_KEY";

  default:
    return "Unknown event";
  }
}
#endif
void RBF_key_group_info_log(void)
{
#if defined (CONFIG_LOG_RBFKEYNVM)
  printf("code A: identifier=%d, key_id=0x%lx \n",
         key_group.codeA.identifier,key_group.codeA.key_id);
  printf("code B: identifier=%d, key_id=0x%lx \n",
         key_group.codeB.identifier,key_group.codeB.key_id);
  printf("code AB: identifier=%d, key_id=0x%lx \n",
         key_group.codeAB.identifier,key_group.codeAB.key_id);

  printf("system_key_code: identifier=%d, key_id=0x%lx \n",
         key_group.system_key_code.identifier,key_group.system_key_code.key_id);

  printf("BROADCAST_key_code: identifier=%d, key_id=0x%lx \n",
         key_group.broadcast_key_code.identifier,key_group.broadcast_key_code.key_id);

  printf("default_key1: identifier=%d, key_id=0x%lx \n",
         key_group.default_key1.identifier,key_group.default_key1.key_id);
  printf("default_key2: identifier=%d, key_id=0x%lx \n",
         key_group.default_key2.identifier,key_group.default_key2.key_id);

  printf("nvm_key: identifier=%d, key_id=0x%lx \n",
         key_group.nvm_key.identifier,key_group.nvm_key.key_id);
  printf("nvm_key_en_key: identifier=%d, key_id=0x%lx \n",
         key_group.nvm_key_en_key.identifier,key_group.nvm_key_en_key.key_id);
#endif
}
/*
 *@param key 从NVM读取的加密key,len=16Bytes
 *@param
 *
 *@note TODO:需要增加NVM区域相应key获取
 *@note KEY_SIM_DEBUG  模拟从NVM读取
 */
void get_key_from_nvm(KeyIdentifier_t keyID, uint8_t *key)
{
  //test 测试数据
//  uint8_t buff[16] = {0xFF,0xFF,3,4,5,6,7,8,9,10,11,12,13,13,14,15};
//  memcpy(key,buff,RBF_KEY_LENGTH_MAX);
  //end test

  //以下根据keyID,读取NVM区域相应的key
  switch(keyID){
    case KEY_ID_CODEA:
#if defined (KEY_SIM_DEBUG)
      memcpy(key,codeA_key.key_c,RBF_KEY_LENGTH_MAX);//模拟读取NVM
#else
      getThisParam(ENpbyKeyA,key);
#endif

      break;
    case KEY_ID_CODEB:
#if defined (KEY_SIM_DEBUG)
      memcpy(key,codeB_key.key_c,RBF_KEY_LENGTH_MAX);//
#else
      getThisParam(ENpbyKeyB,key);
#endif

      break;
    case KEY_ID_CODEAB:
#if defined (KEY_SIM_DEBUG)
      memcpy(key,codeAB_key.key_c,RBF_KEY_LENGTH_MAX);//
#else
      getThisParam(ENpbyCodeABKey,key);
#endif

      break;
    case KEY_ID_DEFAULT_KEY1:
#if defined (KEY_SIM_DEBUG)
      memcpy(key,default_key_1.key_c,RBF_KEY_LENGTH_MAX);//
#else
      getThisParam(ENpbyDefaultKey1,key);
#endif

      break;
    case KEY_ID_DEFAULT_KEY2:
#if defined (KEY_SIM_DEBUG)
      memcpy(key,default_key_2.key_c,RBF_KEY_LENGTH_MAX);//
#else
      getThisParam(ENpbyDefaultKey2,key);
#endif

      break;
    case KEY_ID_SYSTEM_KEY_CODE:
#if defined (KEY_SIM_DEBUG)
      memcpy(key,system_key.key_c,RBF_KEY_LENGTH_MAX);//
#else
      getThisParam(ENpbySystemKey,key);
#endif

      break;
    case KEY_ID_BROADCAST_KEY_CODE:
#if defined (KEY_SIM_DEBUG)
      memcpy(key,broadcast_key.key_c,RBF_KEY_LENGTH_MAX);//
#else
      getThisParam(ENpbyBroadcastKey,key);
#endif

      break;
    case KEY_ID_NVM_KEY:
#if defined (KEY_SIM_DEBUG)
      memcpy(key,nvm_key.key_c,RBF_KEY_LENGTH_MAX);//
#else
      getThisParam(ENpbyNVMKey,key);
#endif

      break;
    case KEY_ID_NVM_KEY_EN_KEY:
      //KEY_ID_NVM_KEY_EN_KEY key为只读，固化在程序中。
      //key_p 和key_c相同。不需要从NVM读取
#if defined (KEY_SIM_DEBUG)
      //TODO:
#else
      getThisParam(ENpbyNVMKeyEN,key);
#endif

      break;
    default:

      break;
  }



}
/*
 *
 *
 *@note TODO:需要增加写相应的key到NVM区域
 */
void set_key_from_nvm(KeyIdentifier_t keyID, uint8_t *key)
{
  //test 测试数据
//  uint8_t buff[16] = {0xFF,0xFF,3,4,5,6,7,8,9,10,11,12,13,13,14,15};
//  memcpy(key,buff,16);
  //end test

  //以下根据keyID,设置NVM区域相应的key

  switch(keyID){
    case KEY_ID_CODEA:
#if defined (KEY_SIM_DEBUG)
      memcpy(codeA_key.key_c,key,RBF_KEY_LENGTH_MAX);//
#else
      setThisParam(ENpbyKeyA,key);
#endif



      break;
    case KEY_ID_CODEB:
#if defined (KEY_SIM_DEBUG)
      memcpy(codeB_key.key_c,key,RBF_KEY_LENGTH_MAX);//
#else
      setThisParam(ENpbyKeyB,key);
#endif

      break;
    case KEY_ID_CODEAB:
#if defined (KEY_SIM_DEBUG)
      memcpy(codeAB_key.key_c,key,RBF_KEY_LENGTH_MAX);//
#else
      setThisParam(ENpbyCodeABKey,key);
#endif

      break;
    case KEY_ID_DEFAULT_KEY1:
#if defined (KEY_SIM_DEBUG)
      memcpy(default_key_1.key_c,key,RBF_KEY_LENGTH_MAX);//
#else
      setThisParam(ENpbyDefaultKey1,key);
#endif

      break;
    case KEY_ID_DEFAULT_KEY2:
#if defined (KEY_SIM_DEBUG)
      memcpy(default_key_2.key_c,key,RBF_KEY_LENGTH_MAX);//
#else
      setThisParam(ENpbyDefaultKey2,key);
#endif

      break;
    case KEY_ID_SYSTEM_KEY_CODE:
#if defined (KEY_SIM_DEBUG)
      memcpy(system_key.key_c,key,RBF_KEY_LENGTH_MAX);//
#else
      setThisParam(ENpbySystemKey,key);
#endif

      break;
    case KEY_ID_BROADCAST_KEY_CODE:
#if defined (KEY_SIM_DEBUG)
      memcpy(broadcast_key.key_c,key,RBF_KEY_LENGTH_MAX);//
#else
      setThisParam(ENpbyBroadcastKey,key);
#endif

      break;
    case KEY_ID_NVM_KEY:
#if defined (KEY_SIM_DEBUG)
      memcpy(nvm_key.key_c,key,RBF_KEY_LENGTH_MAX);//
#else
      setThisParam(ENpbyNVMKey,key);
#endif

      break;
    case KEY_ID_NVM_KEY_EN_KEY:
      //KEY_ID_NVM_KEY_EN_KEY key为只读，固化在程序中。
      //key_p 和key_c相同。不需要从NVM读取
#if defined (KEY_SIM_DEBUG)
      //TODO:
#else
      setThisParam(ENpbyNVMKeyEN,key);
#endif

      break;
    default:

      break;
  }
}
/*
 *@brief 针对NVM区域的key进行加密
 *@param keyID key id标识符
 *@param key值
 *
 */
SecureElementStatus_t secure_element_setKey( KeyIdentifier_t keyID __attribute__((unused)), uint8_t* key __attribute__((unused)))
{
//  uint8_t key_buff[16] ={0};
//    switch(keyID){
//    case KEY_ID_CODEA:
//#if defined (KEY_SIM_DEBUG)
//      //memcpy(codeA_key.key_c,key,RBF_KEY_LENGTH_MAX);//
//#else
//
//#endif
//
//      break;
//
//    }


#if defined (KEY_SIM_DEBUG)
      //memcpy(codeA_key.key_c,key,RBF_KEY_LENGTH_MAX);//
#else

#endif
  return SECURE_ELEMENT_SUCCESS;
}


/*
 *@brief 针对NVM区域的key进行解密
 *@param keyID
 */
SecureElementStatus_t secure_element_getKey( KeyIdentifier_t keyID __attribute__((unused)), uint8_t* key __attribute__((unused)))
{


    return SECURE_ELEMENT_SUCCESS;
}
/*
 *@note: RBM触发配网时，随机生成codeA
 *
 */
SecureElementStatus_t RBF_generate_data_codeA(uint8_t *key)
{

  sl_se_command_context_t cmd_ctx;
  sl_status_t ret;
  uint8_t buff[16];

  ret = sl_se_init_command_context(&cmd_ctx);
  if (ret != SL_STATUS_OK) {
      DS_app_log_error("random data init error\n");
      return SECURE_ELEMENT_ERROR;
  }

  ret = sl_se_get_random(&cmd_ctx,buff,16);
   if (ret != SL_STATUS_OK) {
       DS_app_log_error("generate data error\n");
       return SECURE_ELEMENT_ERROR;
   }
   memcpy(key,buff,16);
#if 0
   DS_app_log_hexdump_error("gen codeA:",buff,16);
#endif

  RBF_set_data_codeA(key);
  return SECURE_ELEMENT_SUCCESS;
}
/*
 *@brief  获取codeA
 *@param
 *@param
 *
 *
 */
SecureElementStatus_t RBF_get_data_codeA (uint8_t *key)
{
  uint8_t default_key[16] = KEY_CODEA_DEFAULT;

  /*
   * 读取NVM区域的key,并进行解密,如果NVM区域没有改key,使用默认key
   *
   */
  //1. get key from nvm
  get_key_from_nvm(KEY_ID_CODEA,key);
  //2. 解密
  secure_element_getKey(KEY_ID_CODEA,key);
  if((key[0] == 0xff && key[1]== 0xFF) ||
      (key[0] == 0 && key[1]== 0)) {
#if (RBF_MODLE  != RBF_MODLE_RBM)
      //TODO:HUB如果读取错误，不能由默认的key替换
      printf("%s",get_status_type_str(SECURE_ELEMENT_ERROR_INVALID_KEY_ID));
      return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
#else
      //RFM读取错误，恢复默认的key
      memcpy(key,default_key,RBF_KEY_LENGTH_MAX);
#endif
  }

#if defined (CONFIG_LOG_RBF_KEY_NVM)
  DS_app_log_hexdump_debug("CodeA key[0]:",default_key,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug("CodeA key[1]:",key,RBF_KEY_LENGTH_MAX);
#endif
  return SECURE_ELEMENT_SUCCESS;
}
/*
 *@brief  设置codeA
 *@param
 *@param
 *
 *
 */
void RBF_set_data_codeA(uint8_t *key)
{

  /*
   * 对key进行设置,并密文保存在nvm区域
   *
   *
   */

  //1。对key进行加密
  secure_element_setKey( KEY_ID_CODEA, key );

  //2.对key保存在NVM
  set_key_from_nvm(KEY_ID_CODEA, key);


}
//void RBF_set_keyid_codeA(uint8_t *key)
//{
//  DS_AES_CCM_STATUS ret = 0;
//  ret = DS_aes_ccm_init(key,RBF_KEY_LENGTH_MAX);
//  if(ret == DS_AES_CCM_STATUS_SUCCESS){
//      key_group.codeA.identifier = KEY_ID_CODEA;
//      key_group.codeA.key_id = DS_aes_ccm_get_key_id();
//  }
//  else{
//      key_group.codeA.identifier = KEY_ID_NOKEY;
//      key_group.codeA.key_id = 0;
//  }
//
//
//
//}
SecureElementStatus_t RBF_generate_data_codeB(uint8_t *key)
{

  sl_se_command_context_t cmd_ctx;
  sl_status_t ret;
  uint8_t buff[16];

  ret = sl_se_init_command_context(&cmd_ctx);
  if (ret != SL_STATUS_OK) {
      DS_app_log_error("random data init error\n");
      return SECURE_ELEMENT_ERROR;
  }

  ret = sl_se_get_random(&cmd_ctx,buff,16);
   if (ret != SL_STATUS_OK) {
       DS_app_log_error("generate data error\n");
       return SECURE_ELEMENT_ERROR;
   }
   memcpy(key,buff,16);
   DS_app_log_hexdump_debug("random data:",buff,16);


  RBF_set_data_codeB(key);
  return SECURE_ELEMENT_SUCCESS;
}

SecureElementStatus_t RBF_generate_data_key(uint8_t *key)
{

  sl_se_command_context_t cmd_ctx;
  sl_status_t ret;
  uint8_t buff[16];

  ret = sl_se_init_command_context(&cmd_ctx);
  if (ret != SL_STATUS_OK) {
      DS_app_log_error("random data init error\n");
      return SECURE_ELEMENT_ERROR;
  }

  ret = sl_se_get_random(&cmd_ctx,buff,16);
   if (ret != SL_STATUS_OK) {
       DS_app_log_error("generate data error\n");
       return SECURE_ELEMENT_ERROR;
   }
   memcpy(key,buff,16);
   DS_app_log_hexdump_debug("random data:",buff,16);

  return SECURE_ELEMENT_SUCCESS;
}
/*
 *@brief  获取codeB
 *@param
 *@param
 *
 *
 */
SecureElementStatus_t RBF_get_data_codeB (uint8_t *key)
{
#if defined (CONFIG_LOG_RBF_KEY_NVM)
  uint8_t default_key[16] = KEY_CODEB_DEFAULT;
#endif

  /*
   * 读取NVM区域的key,并进行解密,如果NVM区域没有改key,使用默认key
   *
   */
  //1. get key from nvm
  get_key_from_nvm(KEY_ID_CODEB,key);
  //2. 解密
  secure_element_getKey(KEY_ID_CODEB,key);
  if((key[0] == 0xff && key[1]== 0xFF)
      ||(key[0] == 0 && key[1]== 0)) {
#if (RBF_MODLE  == RBF_MODLE_RBM)
      //TODO:RBM如果读取错误，不能由默认的key替换
      printf("%s",get_status_type_str(SECURE_ELEMENT_ERROR_INVALID_KEY_ID));
      return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
#else
      //RFM读取错误，恢复默认的key
      memcpy(key,default,RBF_KEY_LENGTH_MAX);
#endif
  }

#if defined (CONFIG_LOG_RBF_KEY_NVM)
  DS_app_log_hexdump_debug("CodeB key[0]:",default_key,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug("CodeB key[1]:",key,RBF_KEY_LENGTH_MAX);
#endif
  return SECURE_ELEMENT_SUCCESS;
}
/*
 *@brief  设置codeB
 *@param
 *@param
 * *
 */
void RBF_set_data_codeB(uint8_t *key)
{

  /*
   * 对key进行设置,并密文保存在nvm区域
   *
   *
   */

  //1。对key进行加密
  secure_element_setKey( KEY_ID_CODEB, key );

  //2.对key保存在NVM
  set_key_from_nvm(KEY_ID_CODEB, key);
}
//void RBF_set_keyid_codeB(uint8_t *key)
//{
//  DS_AES_CCM_STATUS ret = 0;
//
//  ret = DS_aes_ccm_init(key,RBF_KEY_LENGTH_MAX);
//  if(ret == DS_AES_CCM_STATUS_SUCCESS){
//      key_group.codeB.identifier = KEY_ID_CODEB;
//      key_group.codeB.key_id = DS_aes_ccm_get_key_id();
//  }
//  else {
//      key_group.codeB.identifier = KEY_ID_NOKEY;
//      key_group.codeB.key_id = 0;
//  }
//}
/*
 *@brief  获取codeAB
 *@param
 *@param
 *
 *
 */
SecureElementStatus_t RBF_get_data_codeAB (uint8_t *key)
{
#if defined (CONFIG_LOG_RBF_KEY_NVM)
  uint8_t default_key[16] = KEY_CODEAB_DEFAULT;
#endif
  /*
   * 读取NVM区域的key,并进行解密,如果NVM区域没有改key,使用默认key
   *
   */
  //1. get key from nvm
  get_key_from_nvm(KEY_ID_CODEAB,key);
  //2. 解密
  secure_element_getKey(KEY_ID_CODEAB,key);
  if((key[0] == 0xff && key[1]== 0xFF)
      ||(key[0] == 0 && key[1]== 0)) {
      //TODO:HUB和RBM如果读取错误，不能由默认的key替换
      printf("%s",get_status_type_str(SECURE_ELEMENT_ERROR_INVALID_KEY_ID));
      return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
  }

#if defined (CONFIG_LOG_RBF_KEY_NVM)
  DS_app_log_hexdump_debug("CodeAB key[0]:",default_key,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug("CodeAB key code[1]:",key,RBF_KEY_LENGTH_MAX);
#endif
  return SECURE_ELEMENT_SUCCESS;
}
/*
 *@brief  设置codeAB
 *@param
 *@param
 * *
 */
void RBF_set_data_codeAB(uint8_t *key)
{
  /*
   * 对key进行设置,并密文保存在nvm区域
   *
   *
   */

  //1。对key进行加密
  secure_element_setKey( KEY_ID_CODEAB, key );

  //2.对key保存在NVM
  set_key_from_nvm(KEY_ID_CODEAB, key);

}
//void RBF_set_keyid_codeAB(uint8_t *key)
//{
//  DS_AES_CCM_STATUS ret = 0;
//
//  ret = DS_aes_ccm_init(key,RBF_KEY_LENGTH_MAX);
//  if(ret == DS_AES_CCM_STATUS_SUCCESS){
//        key_group.codeAB.identifier = KEY_ID_CODEAB;
//        key_group.codeAB.key_id = DS_aes_ccm_get_key_id();
//  }
//  else {
//      key_group.codeAB.identifier = KEY_ID_NOKEY;
//      key_group.codeAB.key_id = 0;
//      DS_app_log_error("codeAB set keyid error \n");
//  }
//}
/*
 *
 *
 */
SecureElementStatus_t RBF_get_data_nvmKey (uint8_t *key)
{
#if defined (CONFIG_LOG_RBF_KEY_NVM)
  uint8_t default_key[16] = KEY_NVM_DEFAULT;
#endif

  /*
   * 读取NVM区域的key,并进行解密,如果NVM区域没有改key,使用默认key
   *
   */
  //1. get key from nvm
  get_key_from_nvm(KEY_ID_NVM_KEY,key);
  //2. 解密
  secure_element_getKey(KEY_ID_NVM_KEY,key);
  if((key[0] == 0xff && key[1]== 0xFF)
      ||(key[0] == 0 && key[1]== 0x0)) {
#if (RBF_MODLE  == RBF_MODLE_RBM)
      //TODO:RBM如果读取错误，不能由默认的key替换
      printf("%s",get_status_type_str(SECURE_ELEMENT_ERROR_INVALID_KEY_ID));
      return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
#elif
      //HUB读取错误，恢复默认的key
      memcpy(key,default,RBF_KEY_LENGTH_MAX);
#endif
  }

#if defined (CONFIG_LOG_RBF_KEY_NVM)
  DS_app_log_hexdump_debug("nvm key[0]:",default_key,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug("nvm key[1]:",key,RBF_KEY_LENGTH_MAX);
#endif
  return SECURE_ELEMENT_SUCCESS;
}
void RBF_set_data_nvmKey(uint8_t *key)
{
  /*
   * 对key进行设置,并密文保存在nvm区域
   *
   *
   */

  //1。对key进行加密
  secure_element_setKey( KEY_ID_NVM_KEY, key );

  //2.对key保存在NVM
  set_key_from_nvm(KEY_ID_NVM_KEY, key);

}
//void RBF_set_keyid_nvmKey(uint8_t *key)
//{
//  DS_AES_CCM_STATUS ret = 0;
//  ret=DS_aes_ccm_init(key,RBF_KEY_LENGTH_MAX);
//  if(ret == DS_AES_CCM_STATUS_SUCCESS){
//      key_group.nvm_key.identifier = KEY_ID_NVM_KEY;
//      key_group.nvm_key.key_id = DS_aes_ccm_get_key_id();
//  }
//  else {
//      key_group.nvm_key.identifier = KEY_ID_NOKEY;
//      key_group.nvm_key.key_id = 0;
//  }
//}
/*
 *@brief  获取systemKeyCode
 *@param
 *@param
 *
 *
 */
SecureElementStatus_t RBF_get_data_systemKeyCode (uint8_t *key)
{
#if defined (CONFIG_LOG_RBF_KEY_NVM)
  uint8_t default_key[16] = KEY_SYSTEM_DEFAULT;
#endif

  /*
   * 读取NVM区域的key,并进行解密,如果NVM区域没有改key,使用默认key
   *
   */
  //1. get key from nvm
  get_key_from_nvm(KEY_ID_SYSTEM_KEY_CODE,key);
  //2. 解密
  secure_element_getKey(KEY_ID_SYSTEM_KEY_CODE,key);
  if((key[0] == 0xff && key[1]== 0xFF)
      || (key[0] == 0 && key[1]== 0)){
#if (RBF_MODLE  == RBF_MODLE_RBM)
      //TODO:RBM如果读取错误，不能由默认的key替换
      printf("%s",get_status_type_str(SECURE_ELEMENT_ERROR_INVALID_KEY_ID));
      return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
#elif
      //HUB读取错误，恢复默认的key
      memcpy(key,default,RBF_KEY_LENGTH_MAX);
#endif
  }

#if defined (CONFIG_LOG_RBF_KEY_NVM)
  DS_app_log_hexdump_debug("system key code[0]:",default_key,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug("system key code[1]:",key,RBF_KEY_LENGTH_MAX);
#endif
  return SECURE_ELEMENT_SUCCESS;
}
/*
 *@brief  设置systemKeyCode
 *@param
 *@param
 * *
 */
void RBF_set_data_systemKeyCode(uint8_t *key)
{

  /*
   * 对key进行设置,并密文保存在nvm区域
   *
   *
   */

  //1。对key进行加密
  secure_element_setKey( KEY_ID_SYSTEM_KEY_CODE, key );

  //2.对key保存在NVM
  set_key_from_nvm(KEY_ID_SYSTEM_KEY_CODE, key);
}
//void RBF_set_keyid_systemKeyCode(uint8_t *key)
//{
//  DS_AES_CCM_STATUS ret = 0;
//  ret=DS_aes_ccm_init(key,RBF_KEY_LENGTH_MAX);
//  if(ret == DS_AES_CCM_STATUS_SUCCESS){
//      key_group.system_key_code.identifier = KEY_ID_SYSTEM_KEY_CODE;
//      key_group.system_key_code.key_id = DS_aes_ccm_get_key_id();
//  }
//  else {
//      key_group.system_key_code.identifier = KEY_ID_NOKEY;
//      key_group.system_key_code.key_id = 0;
//
//  }
//}
/*
 *@brief  获取broadcastKeyCode
 *@param
 *@param
 *
 *@return  =SECURE_ELEMENT_ERROR_INVALID_KEY_ID, 无效的key.
 *
 */
SecureElementStatus_t RBF_get_data_broadcastKeyCode (uint8_t *key)
{
#if defined (CONFIG_LOG_RBF_KEY_NVM)
  uint8_t default_key[16] = KEY_BROADCAST_DEFAULT;
#endif

  /*
   * 读取NVM区域的key,并进行解密,如果NVM区域没有改key,使用默认key
   *
   */
  //1. get key from nvm
  get_key_from_nvm(KEY_ID_BROADCAST_KEY_CODE,key);
  //2. 解密
  secure_element_getKey(KEY_ID_BROADCAST_KEY_CODE,key);
  if((key[0] == 0xff && key[1]== 0xFF)
      || (key[0] == 0 && key[1]== 0)) {
#if (RBF_MODLE  == RBF_MODLE_RBM)
      //TODO:RBM如果读取错误，不能由默认的key替换
      printf("%s",get_status_type_str(SECURE_ELEMENT_ERROR_INVALID_KEY_ID));
      return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
#elif
      //HUB读取错误，恢复默认的key
      memcpy(key,default,RBF_KEY_LENGTH_MAX);
#endif
  }

#if defined (CONFIG_LOG_RBF_KEY_NVM)
  DS_app_log_hexdump_debug("broadcast key[0]:",default_key,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug("broadcast key[1]:",key,RBF_KEY_LENGTH_MAX);
#endif
  return SECURE_ELEMENT_SUCCESS;
}
/*
 *@brief  设置broadcastKeyCode
 *@param
 *@param
 * *
 */
void RBF_set_data_broadcastKeyCode(uint8_t *key)
{
  /*
   * 对key进行设置,并密文保存在nvm区域
   *
   *
   */

  //1。对key进行加密
  secure_element_setKey( KEY_ID_BROADCAST_KEY_CODE, key );

  //2.对key保存在NVM
  set_key_from_nvm(KEY_ID_BROADCAST_KEY_CODE, key);

}
//void RBF_set_keyid_broadcastKeyCode(uint8_t *key)
//{
//  DS_AES_CCM_STATUS ret = 0;
//  ret=DS_aes_ccm_init(key,RBF_KEY_LENGTH_MAX);
//  if(ret == DS_AES_CCM_STATUS_SUCCESS){
//      key_group.broadcast_key_code.identifier = KEY_ID_BROADCAST_KEY_CODE;
//      key_group.broadcast_key_code.key_id = DS_aes_ccm_get_key_id();
//  }
//  else {
//      key_group.broadcast_key_code.identifier = KEY_ID_NOKEY;
//      key_group.broadcast_key_code.key_id = 0;
//  }
//}
/*
 * 获取defaultKey1
 *
 *
 */
void RBF_get_data_defaultKey1(uint8_t *key)
{

  uint8_t default_key[16] = DEFAULTKEY_1_VALUE_DEFALUT;

  /*
   * 读取NVM区域的key,并进行解密,如果NVM区域没有改key,使用默认key
   *
   */
  //1. get key from nvm
  get_key_from_nvm(KEY_ID_DEFAULT_KEY1,key);
  //2. 解密
  secure_element_getKey(KEY_ID_DEFAULT_KEY1,key);
  if(key[0] == 0xff && key[1]== 0xFF) {
      //TODO.暂定判断读取的key为0xff为非法的key(空的)
      memcpy(key,default_key,RBF_KEY_LENGTH_MAX);
  }

#if defined (CONFIG_LOG_RBF_KEY_NVM)
  DS_app_log_hexdump_debug("default key 1[0]:",default_key,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug("default key 1[1]:",key,RBF_KEY_LENGTH_MAX);

#endif
  //3.
}
/*
 * 该Key用于系统一次性烧录，整个网络的设备必须统一,应用中不提供set接口。
 *
 *
 */
SecureElementStatus_t RBF_set_data_defaultKey1(uint8_t *key)
{
  uint8_t default_key[16] = DEFAULTKEY_1_VALUE_DEFALUT;

  /*
   * 对key进行设置,并密文保存在nvm区域
   *
   *
   */
#if (MANUFACTURER_TYPE == MANUFACTURER_DUSUN)
  //针对DUSUN采用系统默认的key
  memcpy(key,default_key,RBF_KEY_LENGTH_MAX);
#endif

  //1。对key进行加密
  secure_element_setKey( KEY_ID_DEFAULT_KEY1, key );

  //2.对key保存在NVM
  set_key_from_nvm(KEY_ID_DEFAULT_KEY1, key);

  return SECURE_ELEMENT_SUCCESS;
}
//void RBF_set_keyid_defaultKey1(uint8_t *key)
//{
//  DS_AES_CCM_STATUS ret = 0;
//  ret=DS_aes_ccm_init(key,RBF_KEY_LENGTH_MAX);
//  if(ret == DS_AES_CCM_STATUS_SUCCESS){
//      key_group.default_key1.identifier = KEY_ID_DEFAULT_KEY1;
//      key_group.default_key1.key_id = DS_aes_ccm_get_key_id();
//  }
//  else {
//      key_group.default_key1.identifier = KEY_ID_NOKEY;
//      key_group.default_key1.key_id = 0;
//  }
//}
/*
 *
 *
 */
void RBF_get_data_defaultKey2(uint8_t *key)
{
  uint8_t default_key[16] = DEFAULTKEY_2_VALUE_DEFALUT;

  /*
   * 读取NVM区域的key,并进行解密,如果NVM区域没有改key,使用默认key
   *
   */
  //1. get key from nvm
  get_key_from_nvm(KEY_ID_DEFAULT_KEY2,key);
  //2. 解密
  secure_element_getKey(KEY_ID_DEFAULT_KEY2,key);
  if(key[0] == 0xff && key[1]== 0xFF) {
      //TODO.暂定判断读取的key为0xff为非法的key(空的)
      memcpy(key,default_key,RBF_KEY_LENGTH_MAX);
  }

#if defined (CONFIG_LOG_RBF_KEY_NVM)
  DS_app_log_hexdump_debug("default key 2[0]:",default_key,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug("default key 2[1]:",key,RBF_KEY_LENGTH_MAX);
#endif
}
/*
 *@note  该Key用于系统一次性烧录，整个网络的设备必须统一,应用中不提供set接口。
 *@note  为了后期能扩展其它网络，可以根据制造商生成默认的key。
 *@note  DUSUN的key暂时由程序固定
 *@note  TODO:后期对其制造商进行扩展
 *
 */
SecureElementStatus_t RBF_set_data_defaultKey2(uint8_t *key)
{
  uint8_t default_key[16] = DEFAULTKEY_2_VALUE_DEFALUT;

  /*
   * 对key进行设置,并密文保存在nvm区域
   *
   *
   */
#if (MANUFACTURER_TYPE == MANUFACTURER_DUSUN)
  //针对DUSUN采用系统默认的key
  memcpy(key,default_key,RBF_KEY_LENGTH_MAX);
#endif

  //1。对key进行加密
  secure_element_setKey( KEY_ID_DEFAULT_KEY2, key );

  //2.对key保存在NVM
  set_key_from_nvm(KEY_ID_DEFAULT_KEY2, key);

  return SECURE_ELEMENT_SUCCESS;
}
//void RBF_set_keyid_defaultKey2(uint8_t *key)
//{
//  DS_AES_CCM_STATUS ret = 0;
//  ret=DS_aes_ccm_init(key,RBF_KEY_LENGTH_MAX);
//  if(ret == DS_AES_CCM_STATUS_SUCCESS){
//      key_group.default_key2.identifier = KEY_ID_DEFAULT_KEY2;
//      key_group.default_key2.key_id = DS_aes_ccm_get_key_id();
//  }
//  else{
//      key_group.default_key2.identifier = KEY_ID_NOKEY;
//      key_group.default_key2.key_id = 0;
//  }
//
//}
/*
 *@param identifier  key的类型
 *@param key_id      uint32_t类型的key_id
 *@param
 *@note  通过key的类型来获取key_id,如果无效,返回SECURE_ELEMENT_ERROR_INVALID_KEY_ID
 */
SecureElementStatus_t RBF_get_key_id (KeyIdentifier_t identifier,uint32_t * key_id)
{

  if(identifier == KEY_ID_CODEA){
      if(key_group.codeA.identifier == KEY_ID_NOKEY){
          *key_id = 0;
          return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
      }
      else {
          *key_id = key_group.codeA.key_id;
      }
  }
  else if(identifier == KEY_ID_CODEB){
      if(key_group.codeB.identifier == KEY_ID_NOKEY){
          *key_id = 0;
          return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
      }
      else {
          *key_id = key_group.codeB.key_id;
      }
  }
  else if(identifier == KEY_ID_CODEAB){
      if(key_group.codeAB.identifier == KEY_ID_NOKEY){
          *key_id = 0;
          return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
      }
      else {
          *key_id = key_group.codeAB.key_id;
      }
  }
  else if(identifier == KEY_ID_DEFAULT_KEY1){
      if(key_group.default_key1.identifier == KEY_ID_NOKEY){
          *key_id = 0;
          return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
      }
      else {
          *key_id = key_group.default_key1.key_id;
      }
  }
  else if(identifier == KEY_ID_DEFAULT_KEY2){
      if(key_group.default_key2.identifier == KEY_ID_NOKEY){
          *key_id = 0;
          return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
      }
      else {
          *key_id = key_group.default_key2.key_id;
      }
  }
  else if(identifier == KEY_ID_SYSTEM_KEY_CODE){
      if(key_group.system_key_code.identifier == KEY_ID_NOKEY){
          *key_id = 0;
          return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
      }
      else {
          *key_id = key_group.system_key_code.key_id;
      }
  }
  else if(identifier == KEY_ID_BROADCAST_KEY_CODE){
      if(key_group.broadcast_key_code.identifier == KEY_ID_NOKEY){
          *key_id = 0;
          return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
      }
      else {
          *key_id = key_group.broadcast_key_code.key_id;
      }
  }
  else if(identifier == KEY_ID_NVM_KEY){
      if(key_group.nvm_key.identifier == KEY_ID_NOKEY){
          *key_id = 0;
          return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
      }
      else {
          *key_id = key_group.nvm_key.key_id;
      }
  }
  else if(identifier == KEY_ID_NVM_KEY_EN_KEY){
      if(key_group.nvm_key_en_key.identifier == KEY_ID_NOKEY){
          *key_id = 0;
          return SECURE_ELEMENT_ERROR_INVALID_KEY_ID;
      }
      else {
          *key_id = key_group.nvm_key_en_key.key_id;
      }
  }

  return SECURE_ELEMENT_SUCCESS;
}
/*
 *
 *
 */
uint32_t RBF_get_keyid_codeA(void)
{
  return key_group.codeA.key_id;
}
uint32_t RBF_get_keyid_codeB(void)
{
  return key_group.codeB.key_id;
}
uint32_t RBF_get_keyid_codeAB(void)
{
  return key_group.codeAB.key_id;
}
uint32_t RBF_get_keyid_systemKeyCode(void)
{
  return key_group.system_key_code.key_id;
}

uint32_t RBF_get_keyid_broadcastKeyCode(void)
{
  return key_group.broadcast_key_code.key_id;
}

uint32_t RBF_get_keyid_defaultKey1(void)
{
  return key_group.default_key1.key_id;
}
uint32_t RBF_get_keyid_defaultKey2(void)
{
  return key_group.default_key2.key_id;
}
uint32_t RBF_get_keyid_nvmkey(void)
{
  return key_group.nvm_key.key_id;
}
uint32_t RBF_get_keyid_nvmkeyen(void)
{
  return key_group.nvm_key_en_key.key_id;
}


/*
 *获取所有的key,并转换成key_id
 *
 */
void RBF_keyNVM_init (void)
{
  uint8_t _key[RBF_KEY_LENGTH_MAX] ={0};
  uint8_t _keyA[RBF_KEY_LENGTH_MAX] =KEY_CODEA_DEFAULT;
  uint8_t _keyB[RBF_KEY_LENGTH_MAX] =KEY_CODEB_DEFAULT;
  uint8_t _keyAB[RBF_KEY_LENGTH_MAX] =KEY_CODEAB_DEFAULT;
  uint8_t _keydefault1[RBF_KEY_LENGTH_MAX] =DEFAULTKEY_1_VALUE_DEFALUT;
  uint8_t _keydefault2[RBF_KEY_LENGTH_MAX] =DEFAULTKEY_2_VALUE_DEFALUT;
  uint8_t _keysystem[RBF_KEY_LENGTH_MAX] = KEY_SYSTEM_DEFAULT;
  uint8_t _keybroadcast[RBF_KEY_LENGTH_MAX] =KEY_BROADCAST_DEFAULT;
  uint8_t _keynvm[RBF_KEY_LENGTH_MAX] =KEY_NVM_DEFAULT;
//  uint8_t _keynvmen[RBF_KEY_LENGTH_MAX] =KEY_NVM_EN_DEFAULT;

  /*
   *
   *
   */
//测试数据

  RBF_set_data_codeA(_keyA);
  RBF_set_data_codeB(_keyB);
  RBF_set_data_codeAB(_keyAB);

  RBF_set_data_systemKeyCode(_keysystem);
  RBF_set_data_broadcastKeyCode(_keybroadcast);
  RBF_set_data_defaultKey1(_keydefault1);
  RBF_set_data_defaultKey2(_keydefault2);
  RBF_set_data_nvmKey(_keynvm);


//end test

//1.读取NVM中的key,并写入key_id
  RBF_get_data_defaultKey1(_key);
//  RBF_set_keyid_defaultKey1(_key);
  RBF_get_data_defaultKey2(_key);
 // RBF_set_keyid_defaultKey2(_key);

  RBF_get_data_codeA(_key);
 // RBF_set_keyid_codeA(_key);

  RBF_get_data_codeB(_key);
 // RBF_set_keyid_codeB(_key);
//
  RBF_get_data_codeAB(_key);
//  RBF_set_keyid_codeAB(_key);



  //
  RBF_get_data_systemKeyCode(_key);
//  RBF_set_keyid_systemKeyCode(_key);
  RBF_get_data_nvmKey(_key);
//  RBF_set_keyid_nvmKey(_key);
  RBF_get_data_broadcastKeyCode(_key);
//  RBF_set_keyid_broadcastKeyCode(_key);


  RBF_key_group_info_log();
}
#if defined (KEY_SIM_DEBUG)
void RBF_keyNVM_test (void)
{
  uint8_t key[16] ={0};

  printf("======== RBF Key nvm test ========\n");

  //1.codeA
  RBF_set_data_codeA(codeA_key.key_p);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_CODEA),codeA_key.key_p,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_CODEA),codeA_key.key_c,RBF_KEY_LENGTH_MAX);

  memset(key,0,16);
  RBF_get_data_codeA(key);  //读取codeA
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_GET_CODEA),key,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_GET_CODEA),key,RBF_KEY_LENGTH_MAX);

  //2.codeB
  RBF_set_data_codeB(codeB_key.key_p);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_CODEB),codeB_key.key_p,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_CODEB),codeB_key.key_c,RBF_KEY_LENGTH_MAX);

  memset(key,0,16);
  RBF_get_data_codeB(key);  //读取codeB
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_GET_CODEB),key,RBF_KEY_LENGTH_MAX);

  //3.codeAB
  RBF_set_data_codeAB(codeAB_key.key_p);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_CODEAB),codeAB_key.key_p,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_CODEAB),codeAB_key.key_c,RBF_KEY_LENGTH_MAX);

  memset(key,0,16);
  RBF_get_data_codeAB(key);  //读取codeAB
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_GET_CODEAB),key,RBF_KEY_LENGTH_MAX);

  //4.default key 1
  RBF_set_data_defaultKey1(default_key_1.key_p);  //设置default key
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_DEFAULT_KEY1),default_key_1.key_p,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_DEFAULT_KEY1),default_key_1.key_c,RBF_KEY_LENGTH_MAX);

  memset(key,0,16);
  RBF_get_data_defaultKey1(key);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_GET_DEFAULT_KEY1),key,RBF_KEY_LENGTH_MAX);

  //5.default key2
  RBF_set_data_defaultKey2(default_key_2.key_p);  //设置default key
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_DEFAULT_KEY2),default_key_2.key_p,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_DEFAULT_KEY2),default_key_2.key_c,RBF_KEY_LENGTH_MAX);

  memset(key,0,RBF_KEY_LENGTH_MAX);
  RBF_get_data_defaultKey2(key);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_GET_DEFAULT_KEY2),key,RBF_KEY_LENGTH_MAX);

  //6.system key
  RBF_set_data_systemKeyCode(system_key.key_p);  //设置default key
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_SYSTEM_KEY_CODE),system_key.key_p,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_SYSTEM_KEY_CODE),system_key.key_c,RBF_KEY_LENGTH_MAX);


  memset(key,0,RBF_KEY_LENGTH_MAX);
  RBF_get_data_systemKeyCode(key);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_GET_SYSTEM_KEY_CODE),key,RBF_KEY_LENGTH_MAX);

  //7.BROADCAST key RBF_get_data_broadcastKeyCode
  RBF_set_data_broadcastKeyCode(broadcast_key.key_p);  //设置default key
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_BROADCAST_KEY_CODE),broadcast_key.key_p,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_BROADCAST_KEY_CODE),broadcast_key.key_c,RBF_KEY_LENGTH_MAX);

  memset(key,0,RBF_KEY_LENGTH_MAX);
  RBF_get_data_broadcastKeyCode(key);

  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_GET_BROADCAST_KEY_CODE),key,RBF_KEY_LENGTH_MAX);

  //8.nvm key
  RBF_set_data_nvmKey(nvm_key.key_p);  //设置default key
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_NVM_KEY),nvm_key.key_p,RBF_KEY_LENGTH_MAX);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_SET_NVM_KEY),nvm_key.key_c,RBF_KEY_LENGTH_MAX);


  memset(key,0,RBF_KEY_LENGTH_MAX);
  RBF_get_data_nvmKey(key);
  DS_app_log_hexdump_debug(get_event_type_str(KEY_EVENT_GET_NVM_KEY),key,RBF_KEY_LENGTH_MAX);


  //9.nvm key en key

}

#endif

